class WebSocketClient {
  constructor() {
    this.ws = null;
    this.baseUrl = "ws://localhost:8080/supply" || ''; // 从环境变量获取WebSocket基础URL
    this.reconnectAttempts = 0;
    this.maxReconnectAttempts = 5;
    this.reconnectInterval = 3000; // 重连间隔时间(ms)
    this.listeners = {}; // 消息类型监听器映射
    this.connected = false;
    this.token = ''; // 用户认证token
  }

  /**
   * 初始化WebSocket连接
   * @param {String} token - 用户认证token
   * @param {Function} onOpen - 连接成功回调
   * @param {Function} onError - 连接错误回调
   */
  connect(token, onOpen, onError) {
    if (this.ws && this.connected) {
      console.log('WebSocket已连接');
      return;
    }

    this.token = token;

    // 构建WebSocket URL, 携带token用于认证
    const url = `${this.baseUrl}/ws?token=${token}`;

    try {
      this.ws = new WebSocket(url);

      // 连接建立
      this.ws.onopen = () => {
        console.log('WebSocket连接已建立lllllll');
        this.connected = true;
        this.reconnectAttempts = 0;
        if (typeof onOpen === 'function') {
          onOpen();
        }
      };

      // 接收消息
      this.ws.onmessage = (event) => {
        try {
          console.log('收到消息:', event.data);
          const message = JSON.parse(event.data);
          this.handleMessage(message);
        } catch (e) {
          console.error('WebSocket消息解析错误:', e);
        }
      };

      // 连接关闭
      this.ws.onclose = () => {
        this.connected = false;
        console.log('WebSocket连接已关闭');
        this.attemptReconnect();
      };

      // 连接错误
      this.ws.onerror = (error) => {
        console.error('WebSocket连接错误:', error);
        if (typeof onError === 'function') {
          onError(error);
        }
      };
    } catch (error) {
      console.error('WebSocket初始化错误:', error);
      if (typeof onError === 'function') {
        onError(error);
      }
    }
  }

  /**
   * 尝试重新连接
   */
  attemptReconnect() {
    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
      console.log('已达到最大重连次数');
      return;
    }

    this.reconnectAttempts++;
    console.log(`尝试重新连接... (${this.reconnectAttempts}/${this.maxReconnectAttempts})`);

    setTimeout(() => {
      this.connect(this.token);
    }, this.reconnectInterval);
  }

  /**
   * 处理接收到的消息
   * @param {Object} message - 消息对象
   */
  handleMessage(message) {
    const {type, content} = message;

    if (!type) {
      console.error('收到无类型的消息:', message);
      return;
    }

    // 找到对应类型的所有监听器
    const handlers = this.listeners[type] || [];
    if (handlers.length === 0) {
      console.warn(`未找到消息类型 "${type}" 的处理器`);
      return;
    }

    // 解析content
    let parsedContent;
    try {
      parsedContent = typeof content === 'string' ? JSON.parse(content) : content;
    } catch (e) {
      console.error('解析消息内容失败:', e);
      parsedContent = content; // 如果解析失败，使用原始内容
    }

    // 执行所有处理器
    handlers.forEach(handler => {
      try {
        handler(parsedContent, type);
      } catch (e) {
        console.error(`消息处理器执行错误 (类型: ${type}):`, e);
      }
    });
  }

  /**
   * 注册消息监听器
   * @param {String} type - 消息类型
   * @param {Function} callback - 回调函数
   * @returns {Function} - 移除监听器的函数
   */
  on(type, callback) {
    if (!this.listeners[type]) {
      this.listeners[type] = [];
    }

    this.listeners[type].push(callback);

    // 返回移除该监听器的函数
    return () => {
      this.off(type, callback);
    };
  }

  /**
   * 移除特定类型的监听器
   * @param {String} type - 消息类型
   * @param {Function} callback - 要移除的回调函数(可选)
   */
  off(type, callback) {
    if (!this.listeners[type]) return;

    if (callback) {
      // 移除特定回调
      this.listeners[type] = this.listeners[type].filter(cb => cb !== callback);
    } else {
      // 移除该类型的所有回调
      delete this.listeners[type];
    }
  }

  /**
   * 关闭WebSocket连接
   */
  close() {
    if (this.ws) {
      this.ws.close();
      this.connected = false;
      this.ws = null;
      console.log('WebSocket连接已手动关闭');
    }
  }

  /**
   * 检查连接状态
   * @returns {Boolean} - 是否已连接
   */
  isConnected() {
    return this.connected && this.ws && this.ws.readyState === WebSocket.OPEN;
  }
}

// 创建单例实例
const websocketClient = new WebSocketClient();

// 导入store获取userId
import store from '@/store';

// 定义获取userId的函数
const getUserId = () => {
  try {
    const currentTime = new Date().getTime()
    return store.getters.userId || currentTime;
  } catch (error) {
    console.warn('获取userId失败:', error);
    return 'anonymous';
  }
};

// 消息类型常量定义 - 可扩展
export const MessageTypes = {
  NOTIFY: 'notify',         // 通知消息
  CHAT: 'chat',             // 聊天消息
  ORDER_UPDATE: 'orderUpdate', // 订单更新
  SYSTEM: 'system',         // 系统消息
  // 可以根据需要添加更多类型...
  // 使用函数动态获取userId
  get REFRESH_ROLE() {
    return 'refresh_role+' + getUserId();
  }
};

export default websocketClient;
